The present invention relates to media source input devices such as microphones and video cameras, and in particular to the interfacing of media source input devices to application programs.
Traditionally, when one application program connects to a media source, all other application programs are prevented from using that media source. In the context of a common personal computer, when an application program calls to communicate with a media source, the application program calls to the driver files or the dynamic link library (DLL or *.dll) files. Typically, a DLL provides one or more particular functions and a program accesses the function by creating a link to the DLL. DLL's can also contain data. Some DLL's are provided with the operating system (such as the Windows operating system) and are available for any operating system application. Other DLL's are written for a particular application and are loaded with the application program (such a media source control application program). When a media source control application program calls to connect to a media source, at that point, the driver checks to make sure that no other application has opened the particular camera driver file (*.dll), and if no other has, the driver will open the particular driver file. Having done so, there now exists a single threaded connection between the media source (e.g., video camera) and the application program through the opened media source (e.g., video camera) driver file as seen in FIG. 1.
FIG. 1 shows an application program connecting with a media source, which is a video camera. As depicted in FIG. 1, the driver file 14 is opened by the driver 12 which is called by the calling application program 10 and gets loaded in the calling application program's memory. Since the video camera driver file 14 has been opened by the application program 10, the next application that attempts to make a call to the video camera is prevented from doing so. The issues related to conflicts in sharing a media source between multiple application programs is known as contingency issues. There will be contingency issues, since typical input device drivers only allow one application to use the input device data at any given time. This is because the video camera driver file has been loaded in the first application program's memory and is not available to be accessed by another calling program. Therefore, each application program that potentially makes calls to a video camera must account for the presence of another application program possibly already using the camera. Accordingly, such application programs are encumbered by the need to first check to determine whether another first application program was executed that had connected to the video camera, and if so the second calling program must have routines allowing it to negotiate the sharing of the camera. However such sharing is a single-instant one, meaning the that connection between the camera and the first application program would have to be broken (i.e. the first application program would have to be shut down or the video camera turned off) before the connection between camera and the second application program could be established. Authority, priority, and other security aspects as well as appropriate error handling must also be resolved by the communications between the two competing application programs. Presently, no application program even attempts to resolve any of these issues, and therefore if a connection between a calling program and a camera cannot be established, the unexpected application programs errors are resolved by the operating system which issues rather inelegant and undecipherable error messages leaving the ultimate user to only infer that a proper connection could not be established. At best, the second calling application program receives a message that the device being called to is currently in use and not available.
Application programs have continued to grow in size, flexibility and usability, and the trend has been to move away from large monolithic application programs to programs that are made of many smaller sub-programs. This building block approach provides many advantages such as ease of later modification and configurability. Moreover, operating system suppliers, such as Microsoft, have also adopted such a modular approach and hence offer many standard sub-programs or objects that handle many utility-type functions such as queuing files to a printer, and loading and running printer driver (e.g., DLL) files to print files. The driver (e.g., DLL) files themselves are objects or sub-programs. Further, in an effort to allow interoperability between objects and smaller sub-programs written in different high level programming languages, operating systems suppliers have developed models for executable programs, which can be compatible with each other at the binary level. One such model for binary code developed by the Microsoft Corporation is the component object model (COM). The COM enables programmers to develop objects that can be accessed by any COM-compliant application. Although many benefits can be realized by transitioning from large monolithic application programs to sets of smaller sub-programs and objects, those advantages must be balanced against the burdens imposed by the need for the additional routines allowing for inter process communications amongst these sub-programs and objects.
Besides growing in complexity and usability, multi-unit application programs have been migrating from single-host sites to multiple host heterogeneous network environments. Consequently, it is now not unheard of to have a single application program be comprised of many different routines, each written in different high level programming languages and each residing on a separate computer, where all those computers are connected to each other across a network. In such implementations, the demands for efficient intra and inter-network and inter-process communications can take on a life of their own, detracting from the programmer's primary function of writing an application program. The programmer also has to handle the communications issues posed by spreading application programs across a network. Once again, operating systems suppliers have realized this challenge and potential detraction and have addressed it in various ways. For example, Microsoft has extended the COM functionality by developing the distributed component object model (DCOM). DCOM is an extension of COM to support objects distributed across a network. Besides being an extension of COM, DCOM provides an interface that handles the details of network communication protocols allowing application programmers to focus on their primary function of developing application specific programs. DCOM is designed to address the enterprise requirements for distributed component architecture. For example, a business may want to build and deploy a customer order entry application that involves several different areas of functionality such as tax calculation, customer credit verification, inventory management, warranty update and order entry. Using DCOM the application may be built from five separate components and operated on a web server with access via a browser. Each component can reside on a different computer accessing a different database. The programmer can focus on application development and DCOM is there to handle the inter process communications aspects of the separate components of the application program. For example, DCOM would handle the integration of component communication with appropriate queues and the integration of component applications on a server with HTML-based Internet applications.
Thus, while many computer system operating system suppliers are providing many standardized models for executable programs, even such executable programs can only interface with a media source input device on a one-on-one basis. A standardized device driver file, once linked to an application program, is no longer available for use by another program. There is a need to allow multiple application programs to share a single media source input device, which most commonly is a video camera or microphone.